package demo.topTenRanking;

import java.util.Arrays;

/**
 * @ClassName : BubbleSort
 * @Description : 冒泡排序
 * @Author : JB
 * @Date: 2020-10-06 21:25
 */


public class BubbleSort {
   public static  int[] sort1(int[] sourceArray){
       int count = 0;
       // 对 arr 进行拷贝，不改变参数内容
       int[] arr = Arrays.copyOf(sourceArray,sourceArray.length);
       for(int i =0; i < arr.length -1 ;i++){
           // 设定一个标记，若为true，则表示此次循环没有进行交换，也就是待排序列已经有序，排序已经完成。
           boolean falg = true;
           for(int j =0; j+i < arr.length -1; j++){
               if (arr[j + 1] > arr[j]){
                   int temp = arr[j+1];
                   arr[j+1] = arr[j];
                   arr[j] = temp;
                   falg = false;
                   count++;
               }else {
                   count++;
               }
           }
           if (falg){
               break;
           }
       }
       System.out.println(count);
       return arr;
   }

    public static  int[] sort2(int[] sourceArray){
       int cout = 0;
        // 对 arr 进行拷贝，不改变参数内容
        int[] arr = Arrays.copyOf(sourceArray,sourceArray.length);
        for(int i =0; i < arr.length -1 ;i++){

            for(int j =0; j+i < arr.length -1; j++){
                if (arr[j + 1] > arr[j]){
                    int temp = arr[j+1];
                    arr[j+1] = arr[j];
                    arr[j] = temp;
                     cout++;
                }else {
                    cout++;
                }
            }
        }
        System.out.println(cout);
        return arr;
    }

    /**
     * @author jyroy
     * 冒泡排序常规版
     */
    public static void BubbleSortNormal() {
            int[] list = {3,4,1,5,2};
            int temp = 0; // 开辟一个临时空间, 存放交换的中间值
            // 要遍历的次数
            for (int i = 0; i < list.length-1; i++) {
                System.out.format("第 %d 遍：\n", i+1);
                //依次的比较相邻两个数的大小，遍历一次后，把数组中第i小的数放在第i个位置上
                for (int j = 0; j < list.length-1-i; j++) {
                    // 比较相邻的元素，如果前面的数小于后面的数，就交换
                    if (list[j] < list[j+1]) {
                        temp = list[j+1];
                        list[j+1] = list[j];
                        list[j] = temp;
                    }
                    System.out.format("第 %d 遍的第%d 次交换：", i+1,j+1);
                    for(int count:list) {
                        System.out.print(count);
                    }
                    System.out.println("");
                }
                System.out.format("第 %d 遍最终结果：", i+1);
                for(int count:list) {
                    System.out.print(count);
                }
                System.out.println("\n#########################");
            }
        }


    /**
     * @author jyroy
     * 冒泡排序优化第一版
     */

        public static void BubbleSoerOpt1() {
            int[] list = {5,4,3,1,2};
            int temp = 0; // 开辟一个临时空间, 存放交换的中间值
            // 要遍历的次数
            for (int i = 0; i < list.length-1; i++) {
                int flag = 1; //设置一个标志位
                //依次的比较相邻两个数的大小，遍历一次后，把数组中第i小的数放在第i个位置上
                for (int j = 0; j < list.length-1-i; j++) {
                    // 比较相邻的元素，如果前面的数小于后面的数，交换
                    if (list[j] < list[j+1]) {
                        temp = list[j+1];
                        list[j+1] = list[j];
                        list[j] = temp;
                        flag = 0;  //发生交换，标志位置0
                    }
                }
                System.out.format("第 %d 遍最终结果：", i+1);
                for(int count:list) {
                    System.out.print(count);
                }
                System.out.println("");
                if (flag == 1) {//如果没有交换过元素，则已经有序
                    return;
                }

            }
        }




    public static void main(String[] args) {
       /*int[] a = {1,2,3,4,5,6,7,8,10,9};
       sort1(a);
       sort2(a);*/
        //BubbleSortNormal();
        BubbleSoerOpt1();
    }

}
